home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / QuickDraw GX / QuickDraw GX Info / QuickDraw GX Interfaces / Interfaces & Libraries / graphics libraries / mapping library.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-30  |  5.5 KB  |  155 lines  |  [TEXT/MPS ]
  1. /* Mapping generation routines
  2.     by Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  3.     Copyright 1987 - 1991 Apple Computer, Inc.  All rights reserved.    */
  4.  
  5. #include "graphics libraries.h"
  6.  
  7. static void PolyToPoint(const gxPolygon *poly, gxPoint *pt)
  8. {
  9.     register Fixed x = fixed1, y = fixed1;
  10.     gxPoint pt1, pt2;
  11.     if (poly->vectors > 1)
  12.     {   pt1.x = poly->vector[1].x - poly->vector[0].x;
  13.         pt1.y = poly->vector[1].y - poly->vector[0].y;
  14.         y = Magnitude(pt1.x, pt1.y);
  15.         switch (poly->vectors)
  16.         {   case 2:
  17.             break;
  18.             case 3:
  19.                 pt2.x = poly->vector[0].y - poly->vector[2].y;
  20.                 pt2.y = poly->vector[2].x - poly->vector[0].x;
  21.             goto calcX;
  22.             default:
  23.                 pt2.x = poly->vector[0].y - poly->vector[3].y;
  24.                 pt2.y = poly->vector[3].x - poly->vector[0].x;
  25.             calcX:
  26.                 x = VectorMultiplyDivide(2, &pt1.x, 1, &pt2.x, 1, y);
  27.             break;
  28.         }
  29.     }
  30.     pt->x = x;
  31.     pt->y = y;
  32. }
  33.  
  34. static void Map1Pt(const gxPoint *source, Fixed *dest)
  35. {
  36.     register Fixed *destPtr = dest;
  37.     register const gxPoint *srcPt = source;
  38.     *destPtr++ = fixed1;
  39.     *destPtr++ = 0;
  40.     *destPtr++ = 0;
  41.     *destPtr++ = 0;
  42.     *destPtr++ = fixed1;
  43.     *destPtr++ = 0;
  44.     *destPtr++ = srcPt[0].x;
  45.     *destPtr++ = srcPt[0].y;
  46.     *destPtr = fract1;
  47. }
  48.  
  49. static void Map2Pt(const gxPoint *source, Fixed *dest, Fixed scale)
  50. {
  51.     register Fixed *destPtr = dest;
  52.     register const gxPoint *srcPt = source;
  53.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scale);
  54.     *destPtr++ = FixedDivide(srcPt[0].x - srcPt[1].x, scale);
  55.     *destPtr++ = 0;
  56.     *destPtr++ = FixedDivide(srcPt[1].x - srcPt[0].x, scale);
  57.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scale);
  58.     *destPtr++ = 0;
  59.     *destPtr++ = srcPt[0].x;
  60.     *destPtr++ = srcPt[0].y;
  61.     *destPtr = fract1;
  62. }
  63.  
  64. static void Map3Pt(const gxPoint *source, Fixed *dest, Fixed scaleX, Fixed scaleY)
  65. {
  66.     register Fixed *destPtr = dest;
  67.     register const gxPoint *srcPt = source;
  68.     *destPtr++ = FixedDivide(srcPt[2].x - srcPt[0].x, scaleX);
  69.     *destPtr++ = FixedDivide(srcPt[2].y - srcPt[0].y, scaleX);
  70.     *destPtr++ = 0;
  71.     *destPtr++ = FixedDivide(srcPt[1].x - srcPt[0].x, scaleY);
  72.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scaleY);
  73.     *destPtr++ = 0;
  74.     *destPtr++ = srcPt[0].x;
  75.     *destPtr++ = srcPt[0].y;
  76.     *destPtr = fract1;
  77. }
  78.  
  79. static void Map4Pt(const gxPoint *source, Fixed *dest, Fixed scaleX, Fixed scaleY)
  80. {
  81.     register Fixed *destPtr = dest;
  82.     register const gxPoint *srcPt = source;
  83.     fract a1, a2;
  84.     Fixed x0, y0, x1, y1, x2, y2;
  85.  
  86.     x0 = srcPt[2].x - srcPt[0].x;
  87.     y0 = srcPt[2].y - srcPt[0].y;
  88.     x1 = srcPt[2].x - srcPt[1].x;
  89.     y1 = srcPt[2].y - srcPt[1].y;
  90.     x2 = srcPt[2].x - srcPt[3].x;
  91.     y2 = srcPt[2].y - srcPt[3].y;
  92.  
  93.     /* check if abs(x2) > abs(y2) */
  94.     if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2)
  95.         a1 = FractDivide(MultiplyDivide(x0 - x1, y2, x2) - y0 + y1, MultiplyDivide(x1, y2, x2) - y1);
  96.     else
  97.         a1 = FractDivide(x0 - x1 - MultiplyDivide(y0 - y1, x2, y2), x1 - MultiplyDivide(y1, x2, y2));
  98.  
  99.     /* check if abs(x1) > abs(y1) */
  100.     if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1)
  101.         a2 = FractDivide(y0 - y2 - MultiplyDivide(x0 - x2, y1, x1), y2 - MultiplyDivide(x2, y1, x1));
  102.     else
  103.         a2 = FractDivide(MultiplyDivide(y0 - y2, x1, y1) - x0 + x2, MultiplyDivide(y2, x1, y1) - x2);
  104.  
  105.     *destPtr++ = FixedDivide(FractMultiply(a2, srcPt[3].x) + srcPt[3].x - srcPt[0].x, scaleX);
  106.     *destPtr++ = FixedDivide(FractMultiply(a2, srcPt[3].y) + srcPt[3].y - srcPt[0].y, scaleX);
  107.     *destPtr++ = FixedDivide(a2, scaleX);
  108.     *destPtr++ = FixedDivide(FractMultiply(a1, srcPt[1].x) + srcPt[1].x - srcPt[0].x, scaleY);
  109.     *destPtr++ = FixedDivide(FractMultiply(a1, srcPt[1].y) + srcPt[1].y - srcPt[0].y, scaleY);
  110.     *destPtr++ = FixedDivide(a1, scaleY);
  111.     *destPtr++ = srcPt[0].x;
  112.     *destPtr++ = srcPt[0].y;
  113.     *destPtr = fract1;
  114. }
  115.  
  116. void PolyToPolyMap(const gxPolygon *source, const gxPolygon *dest, gxMapping *map)
  117. {
  118.     gxPoint tempPt;
  119.     gxMapping tempMap;
  120.     long vectors = source->vectors;
  121.  
  122.     if( vectors != dest->vectors && (vectors < 4 || dest->vectors < 4) ) {
  123.         GXPostGraphicsWarning(polygons_have_different_size_contours);
  124.         if (vectors > dest->vectors) vectors = dest->vectors;
  125.     }
  126.     PolyToPoint(source, &tempPt);
  127.     switch (vectors)
  128.     {   case 0:
  129.             ResetMapping(map);
  130.             break;
  131.         case 1:
  132.             Map1Pt(source->vector, &tempMap.map[0][0]);
  133.             InvertMapping(map, &tempMap);
  134.             Map1Pt(dest->vector, &tempMap.map[0][0]);
  135.             goto mapMap;
  136.         case 2:
  137.             Map2Pt(source->vector, &tempMap.map[0][0], tempPt.y);
  138.             InvertMapping(map, &tempMap);
  139.             Map2Pt(dest->vector, &tempMap.map[0][0], tempPt.y);
  140.             goto mapMap;
  141.         case 3:
  142.             Map3Pt(source->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  143.             InvertMapping(map, &tempMap);
  144.             Map3Pt(dest->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  145.             goto mapMap;
  146.         default:
  147.             Map4Pt(source->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  148.             InvertMapping(map, &tempMap);
  149.             Map4Pt(dest->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  150.         mapMap:
  151.             MapMapping(map, &tempMap);
  152.             break;
  153.     }
  154. }
  155.